/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package AccesAuxDonnees;

import Metier.*;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;


/**
 *
 * @author Marc
 */
public class RqtDispenser {

    private DAO dao;
    ResultSet res;
    private final String ADD_LIEN = "INSERT INTO liens_hypertexte (Liens) VALUES (?);";
    private final String ADD_LIENDESCRIPTIF = "INSERT INTO hypertexte_descriptif VALUES "
            + "((SELECT ID_LIENS FROM liens_hypertexte WHERE LIENS = ?),(SELECT ID_DESCRIPTIF FROM descriptif_complexe WHERE TEXTE = ?));";
    private final String ADD_POITOLIEU = "INSERT INTO poi_lieux VALUES (?,?)";
    private final String UPDATE_POI = "UPDATE poi SET libelle = ? WHERE ID_POI= ? ";
    private final String UPDATE_DESCRIPTIFBYPOI = "UPDATE descriptif_complexe SET texte = ? WHERE ID_DESCRIPTIF = (SELECT ID_DESCRIPTIF FROM poi WHERE ID_POI = ?) ";
    private final String UPDATE_LIENBYPOI = "UPDATE liens_hypertexte SET Liens = ? WHERE LIENS = ?";
    private final String SELECT_URLLIBELLE = "SELECT NOM, CARTE FROM LIEUX";

    public RqtDispenser() {
        dao = new DAO();
        res = null;
    }

    public ResultSet requeteTest() {

        Connection conn = dao.obtenirConnexion();
        try (Statement st = conn.createStatement()) {
            res = st.executeQuery("SELECT 'NOM' FROM LIEUX");
        } catch (SQLException e) {
            throw new RuntimeException("Execution de la requête impossible.");
        }

        return res;
    }

    //---------------GESTION DE POI---------------------
    //Ajouter un POI
    public void AddPoi(String libelle, Integer X, Integer Y, String descriptif) {
        Connection conn = dao.obtenirConnexion();

        try (Statement st = conn.createStatement()) {
            st.executeUpdate("INSERT INTO poi(ID_DESCRIPTIF, LIBELLE, X, Y) VALUES "
                    + "((SELECT ID_Descriptif FROM descriptif_complexe WHERE TEXTE = '" + descriptif + "'),'" + libelle + "' ," + X + "," + Y + ");");
        } catch (SQLException e) {
            throw new RuntimeException("Execution de la requête AddPOI impossible.");
        }
    }

    //Select ID d'un POI
    public Integer getIDPOI(String libelle, Integer X, Integer Y) {
        Integer id_poi = 0;
        Connection conn = dao.obtenirConnexion();
        try (Statement st = conn.createStatement()) {
            res = st.executeQuery("SELECT ID_POI FROM poi WHERE LIBELLE = '" + libelle + "' AND X = " + X + " AND Y = " + Y + ";");
            while (res.next()) {
                id_poi = res.getInt("ID_POI");
            }
        } catch (SQLException ex) {
            throw new RuntimeException("Execution de la requête getIDPOI impossible.");
        }
        return id_poi;
    }

    //Supprimer un POI
    public void DeletePOI(POI poi) {
        Connection conn = dao.obtenirConnexion();
        try (Statement st = conn.createStatement()) {
            st.executeUpdate("DELETE FROM poi WHERE ID_POI = " + poi.getId());
        } catch (SQLException ex) {
            throw new RuntimeException("Impossible de supprimer un POI");
        }
    }

    //Récupération de pois d'un lieu
    public List<POI> getPOIS(String nom) {
        List<POI> pois = new ArrayList<>();
        Connection conn = dao.obtenirConnexion();
        try (Statement st = conn.createStatement()) {
            res = st.executeQuery("SELECT POI.ID_POI, POI.libelle, POI.X, POI.Y\n"
                    + "FROM POI\n"
                    + "INNER JOIN POI_LIEUX\n"
                    + "ON POI_LIEUX.ID_poi = POI.ID_POI\n"
                    + "INNER JOIN LIEUX\n"
                    + "ON LIEUX.ID_LIEUX = POI_LIEUX.ID_LIEUX");
            while (res.next()) {
                POI un_poi = new POI();
                un_poi.setId(res.getInt("ID_POI"));
                un_poi.setLibelle(res.getString("libelle"));
                un_poi.setX(res.getInt("X"));
                un_poi.setY(res.getInt("Y"));
                pois.add(un_poi);
            }

        } catch (SQLException ex) {
            throw new RuntimeException("Execution de la requête getPOIS impossible.");
        }
        return pois;
    }

    //Obtenir descriptif et lien pour chaque POI
    public List<String> getDescriptifLienByPOI(POI poi) {
        Connection conn = dao.obtenirConnexion();
        List<String> list_lien = new ArrayList<>();
        try (Statement st = conn.createStatement()) {
            res = st.executeQuery("SELECT descriptif_complexe.Texte, liens_hypertexte.liens "
                    + "FROM liens_hypertexte "
                    + "INNER JOIN hypertexte_descriptif ON liens_hypertexte.ID_LIENS = hypertexte_descriptif.ID_LIENS "
                    + "INNER JOIN descriptif_complexe ON hypertexte_descriptif.ID_DESCRIPTIF = descriptif_complexe.ID_DESCRIPTIF "
                    + "INNER JOIN poi ON descriptif_complexe.ID_DESCRIPTIF = poi.ID_DESCRIPTIF "
                    + "WHERE poi.ID_POI = " + poi.getId());
            while (res.next()) {
                poi.setTexte(res.getString("Texte"));
                list_lien.add(res.getString("liens"));
            }
        } catch (SQLException ex) {
            throw new RuntimeException("Execution de la requête SelectNomLieu impossible.");
        }
        return list_lien;
    }

    //Modification Libelle d'un POI
    public void modifyLibellePOI(POI poi) {
        Connection conn = dao.obtenirConnexion();
        try (PreparedStatement st = conn.prepareStatement(UPDATE_POI)) {
            st.setString(1, poi.getLibelle());
            st.setInt(2, poi.getId());
            st.execute();
        } catch (SQLException ex) {
            throw new RuntimeException("Erreur dans la requête de modification de POI");
        }
    }

    //---------------------GESTION DE DESCRIPTION COMPLEXE---------------------------
    //Ajout de descriptif
    public void AddDescriptif(String Descriptif) {
        Connection conn = dao.obtenirConnexion();

        try (Statement st = conn.createStatement()) {
            st.executeUpdate("INSERT INTO descriptif_complexe(TEXTE) VALUES ('" + Descriptif + "');");
        } catch (SQLException e) {
            throw new RuntimeException("Execution de la requête AddDescriptif impossible.");
        }
    }

    //Modification de descriptif
    public void modifyDescriptifByPOI(POI poi) {
        Connection conn = dao.obtenirConnexion();
        try (PreparedStatement st = conn.prepareStatement(UPDATE_DESCRIPTIFBYPOI)) {
            st.setString(1, poi.getTexte());
            st.setInt(2, poi.getId());
            st.execute();
        } catch (SQLException ex) {
            throw new RuntimeException("Erreur dans la requête de modification de Descriptif");
        }
    }

    //---------------------GESTTION DE LIEU--------------------
    //Ajout de lieu
    public void AddLieu(String libelle, String carte) {
        Connection conn = dao.obtenirConnexion();
        try (Statement st = conn.createStatement()) {
            st.executeUpdate("INSERT INTO lieux (ID_Descriptif, CARTE, NOM) VALUES ((SELECT MAX(ID_DESCRIPTIF) FROM descriptif_complexe),'"+carte+"','" + libelle + "');");
        } catch (SQLException ex) {
            throw new RuntimeException("Execution de la requête AddLieu impossible.");
        }
    }
 
    public void DeleteLinkLieuxWithPoi(String Libelle) {
        Connection conn = dao.obtenirConnexion();
        try (Statement st = conn.createStatement()) {
            st.executeUpdate("DELETE FROM poi_lieux WHERE ID_Lieux=(Select ID_Lieux FROM Lieux  WHERE Nom ='"+Libelle+"')");
        } catch (SQLException ex) {
            throw new RuntimeException("Execution de la requête DeleteLinkLieuxWithPoi impossible.");
        }
    }
      public void SupprimerLieux(String Libelle) {
        Connection conn = dao.obtenirConnexion();

        try (Statement st = conn.createStatement()) {
            st.executeUpdate("DELETE FROM Lieux WHERE Nom ='" + Libelle + "'");
        } catch (SQLException ex) {
            throw new RuntimeException("Execution de la requête SupprimerLieux impossible.");
        }
    }
    
    //Association d'un poi à un lieu

    public void AddPOItoLieu(POI poi, Lieu lieu) {
        Connection conn = dao.obtenirConnexion();
        try (PreparedStatement st = conn.prepareStatement(ADD_POITOLIEU)) {
            st.setInt(1, poi.getId());
            st.setInt(2, lieu.getId());
            st.execute();
        } catch (SQLException ex) {
            throw new RuntimeException("Execution de la requête AddPOItoLieu impossible.");

        }
    }

    public List<Lieu> SelectUrlEtLibelleLieu() {
        List<Lieu> listlieu = new ArrayList();
        Connection conn = dao.obtenirConnexion();
        ResultSet res = null;
        try (PreparedStatement st = conn.prepareStatement(SELECT_URLLIBELLE)) {
            res = st.executeQuery();

            while (res.next()) {
                listlieu.add(new Lieu(res.getString("NOM"), res.getString("CARTE")));
            }
        } catch (SQLException ex) {
            throw new RuntimeException("Execution de la requête Selecturletnomlieu impossible.");
        }
        return listlieu;
    }
    //-----------------------GESTION DES PARCOURS------------------

    public List<POI> SelectPoiParcours(String NomLieux) {

        List<POI> ListePOIElement = new ArrayList<>();

        Connection conn = dao.obtenirConnexion();
        try (Statement st = conn.createStatement()) {

            res = st.executeQuery("SELECT POI.LIBELLE, POI.ID_POI FROM POI "
                    + "INNER JOIN POI_LIEUX ON POI.ID_POI = POI_LIEUX.ID_POI "
                    + "INNER JOIN LIEUX ON POI_LIEUX.ID_LIEUX = LIEUX.ID_LIEUX "
                    + "WHERE CARTE =  '" + NomLieux + "'");
            while (res.next()) {
                POI poi = new POI();
                poi.setId(res.getInt("POI.ID_POI"));
                poi.setLibelle(res.getString("POI.LIBELLE"));
                ListePOIElement.add(poi);
            }

        } catch (SQLException e) {
            throw new RuntimeException("Execution de la requête impossible.");
        }

        return ListePOIElement;
    }

    public void AddParcours(String Descriptif, String Libelle, String ID_Lieux) {
        Connection conn = dao.obtenirConnexion();
        try (Statement st = conn.createStatement()) {
            st.executeUpdate("INSERT INTO parcours_thematique(ID_DESCRIPTIF, LIBELLE,ID_LIEUX) VALUES"
                    + "((SELECT ID_Descriptif FROM descriptif_complexe WHERE TEXTE = '" + Descriptif + "'),'" + Libelle + "',(SELECT ID_LIEUX FROM LIEUX WHERE CARTE = '" + ID_Lieux + "'))");
        } catch (SQLException ex) {
            throw new RuntimeException(ex.getMessage());

        }
    }

    public void LinkParcoursToPOI(List<String> ListLibellePOI, String Libelle) {
        Connection conn = dao.obtenirConnexion();

        try (Statement st = conn.createStatement()) {
            for (String LibellePOI : ListLibellePOI) {
                st.executeUpdate("INSERT INTO poi_parcours(ID_POI,ID_PARCOURS) VALUES((SELECT ID_POI FROM POI WHERE Libelle = '" + LibellePOI + "'),(SELECT ID_PARCOURS FROM parcours_thematique WHERE Libelle = '" + Libelle + "'))");
            }
        } catch (SQLException ex) {
            throw new RuntimeException(ex.getMessage());
        }
    }
    //Selection d'un lieu selon le nom

    public Lieu SelectLieu(String nom) {
        Connection conn = dao.obtenirConnexion();
        Lieu lieu = null;
        try (Statement st = conn.createStatement()) {
            res = st.executeQuery("SELECT * FROM LIEUX WHERE NOM = '" + nom + "'");
            while (res.next()) {

                lieu = new Lieu(res.getString("NOM"), res.getInt("ID_LIEUX"), res.getString("CARTE"));
            }
        } catch (SQLException ex) {
            throw new RuntimeException("Execution de la requête SelectLieu impossible.");
        }

        return lieu;
    }

    public void DeletePOIFromLieu(POI poi) {
        Connection conn = dao.obtenirConnexion();
        try (Statement st = conn.createStatement()) {
            st.executeUpdate("DELETE FROM poi_lieux WHERE ID_POI = " + poi.getId());
        } catch (SQLException ex) {
            throw new RuntimeException(ex.getMessage() + "Execution de la requête DELETEPOI impossible.");
        }
    }

    public List<Parcours> SelectParcoursModification() {
        Connection conn = dao.obtenirConnexion();
        Parcours parcours = null;
        List<Parcours> ListParcours = new ArrayList<>();

        try (Statement st = conn.createStatement()) {
            res = st.executeQuery("SELECT parcours_thematique.ID_Parcours,parcours_thematique.Libelle,descriptif_complexe.Texte FROM parcours_thematique"
                    + " INNER JOIN descriptif_complexe ON parcours_thematique.ID_Descriptif=descriptif_complexe.ID_Descriptif");
            while (res.next()) {

                parcours = new Parcours(res.getString("parcours_thematique.Libelle"), res.getString("descriptif_complexe.Texte"), res.getInt("parcours_thematique.ID_Parcours"));
                ListParcours.add(parcours);
            }
        } catch (SQLException ex) {
            throw new RuntimeException("Execution de la requête SelectLieu impossible.");
        }

        return ListParcours;
    }

    public List<POI> getPOIByParcours(String NomParcours) {
        Connection conn = dao.obtenirConnexion();
        List<POI> ListePoiParcours = new ArrayList<>();

        try (Statement st = conn.createStatement()) {
            res = st.executeQuery("SELECT POI.LIBELLE, POI.ID_POI FROM POI "
                    + "INNER JOIN POI_PARCOURS ON POI.ID_POI = POI_PARCOURS.ID_POI "
                    + "INNER JOIN parcours_thematique ON POI_PARCOURS.ID_Parcours=parcours_thematique.ID_Parcours "
                    + "WHERE parcours_thematique.Libelle =  '" + NomParcours + "'");
            while (res.next()) {
                POI poi = new POI();
                poi.setId(res.getInt("POI.ID_POI"));
                poi.setLibelle(res.getString("POI.LIBELLE"));
                ListePoiParcours.add(poi);
            }
        } catch (SQLException ex) {
            throw new RuntimeException("Execution de la requête SelectLieu impossible.");
        }

        return ListePoiParcours;
    }

    public void ModifierLibelleParcours(String OldLibelle, String NewLibelle) {
        Connection conn = dao.obtenirConnexion();

        try (Statement st = conn.createStatement()) {
            st.executeUpdate("UPDATE parcours_thematique SET LIBELLE =  '" + NewLibelle + "' WHERE LIBELLE ='" + OldLibelle + "' ");

        } catch (SQLException ex) {
            throw new RuntimeException("Execution de la requête ModifierLibelleParcours impossible.");
        }
    }

    public void ModifierDescriptifParcours(String OldDescriptif, String NewDescriptif) {
        Connection conn = dao.obtenirConnexion();

        try (Statement st = conn.createStatement()) {
            st.executeUpdate("UPDATE  descriptif_complexe SET Texte =  '" + NewDescriptif + "' WHERE  Texte='" + OldDescriptif + "' ");
        } catch (SQLException ex) {
            throw new RuntimeException("Execution de la requête ModifierLibelleParcours impossible.");
        }
    }

    public void DeleteLinkParcoursPoi(List<String> ListOldPoi) {
        Connection conn = dao.obtenirConnexion();

        try (Statement st = conn.createStatement()) {
            for (String POIS : ListOldPoi) {
                st.executeUpdate("DELETE FROM poi_parcours WHERE ID_POI =(SELECT ID_POI FROM POI WHERE LIBELLE ='" + POIS + "')");
            }
        } catch (SQLException ex) {
            throw new RuntimeException("Execution de la requête ModifierLibelleParcours impossible.");
        }
    }

    public void SupprimerParcours(String Libelle) {
        Connection conn = dao.obtenirConnexion();

        try (Statement st = conn.createStatement()) {
            st.executeUpdate("DELETE FROM parcours_thematique WHERE Libelle ='" + Libelle + "'");
        } catch (SQLException ex) {
            throw new RuntimeException("Execution de la requête ModifierLibelleParcours impossible.");
        }
    }

    public void DeleteLinkParcoursWithPoi(String Libelle) {
        Connection conn = dao.obtenirConnexion();
        try (Statement st = conn.createStatement()) {
            st.executeUpdate("DELETE FROM poi_parcours WHERE ID_Parcours =(Select ID_Parcours FROM parcours_thematique WHERE Libelle ='" + Libelle + "')");
        } catch (SQLException ex) {
            throw new RuntimeException("Execution de la requête ModifierLibelleParcours impossible.");
        }
    }

//-----------------------GESTION DE LIEN HYPERTEXTE------------------
//Ajout de lien
    public void AddLien(String lien) {
        Connection conn = dao.obtenirConnexion();
        try (PreparedStatement st = conn.prepareStatement(ADD_LIEN)) {
            st.setString(1, lien);
            st.execute();
        } catch (SQLException ex) {
            throw new RuntimeException("Exécution de la requête ADDLien impossible");
        }
    }

    //Association lien et descriptif
    public void AddLienToDescriptif(String lien, String descriptif) {
        Connection conn = dao.obtenirConnexion();
        try (PreparedStatement st = conn.prepareStatement(ADD_LIENDESCRIPTIF)) {
            st.setString(1, lien);
            st.setString(2, descriptif);
            st.execute();
        } catch (SQLException ex) {
            throw new RuntimeException("Exécution de la requête ADDLienDescriptif impossible");
        }
    }

    //Marche pas encore
    //Modification de lien par POI
    /*public void ModifyLienByPOI(POI poi, List<String> list_liens) {
     Connection conn = dao.obtenirConnexion();
     try (PreparedStatement st = conn.prepareStatement(UPDATE_LIENBYPOI)) {
     st.setString(1, s);
     st.setString(2, lien);
     st.execute();
     } catch (SQLException ex) {
     throw new RuntimeException(ex.getMessage());
     }
     }*/
    public List<Lieu> requeteDeRechercheLieu(String chaineArechercher, boolean rechercheSpecifique) {
        Connection conn = dao.obtenirConnexion();
        List<Lieu> listeDeDescriptables = new ArrayList<>();
        String nom = "";
        String carte = "";
        boolean trouve;
        boolean continuer = false;
        boolean refaireUnTour = false;
        boolean ligneRsValide = true;
        int compteur;

        try (Statement st = conn.createStatement()) {
            if (!rechercheSpecifique) {
                res = st.executeQuery("SELECT NOM, CARTE \n"
                        + "FROM (LIEUX INNER JOIN DESCRIPTIF_COMPLEXE \n"
                        + "ON LIEUX.ID_DESCRIPTIF = DESCRIPTIF_COMPLEXE.ID_DESCRIPTIF)\n"
                        + "WHERE TEXTE LIKE \"%" + chaineArechercher + "%\" OR NOM LIKE \"%" + chaineArechercher + "%\" ");
            } else {
  //              res = st.executeQuery("SELECT NOM, CARTE \n"
 //                       + "FROM (LIEUX \n"
//                        + "INNER JOIN DESCRIPTIF_COMPLEXE \n"
//                        + "ON LIEUX.ID_DESCRIPTIF = DESCRIPTIF_COMPLEXE.ID_DESCRIPTIF)\n"
//                        + "WHERE TEXTE = \"" + chaineArechercher + "\" OR NOM = \"" + chaineArechercher + "\"");
                res = st.executeQuery("SELECT NOM, CARTE "
                        + "FROM (LIEUX \n"
                        + "INNER JOIN DESCRIPTIF_COMPLEXE \n"
                        + "ON LIEUX.ID_DESCRIPTIF = DESCRIPTIF_COMPLEXE.ID_DESCRIPTIF) "
                        + "WHERE TEXTE = "+chaineArechercher+" OR NOM = "+chaineArechercher+" ");
            }
            do {
            //    res.first();
                res.beforeFirst();
                //On décale le curseur sur une ligne dont le nom n'est pas encore présent dans la listeDeDescriptables
                do {
                    //Si on a encore des lignes de resultset à parcourir
                    if (res.next()) {                       
                        continuer = false;

                        for (Descriptable descriptableCourant : listeDeDescriptables) {
                            if (descriptableCourant.getLibelle().equals(res.getString("NOM"))) {
                                //On indique que le lieu dont on a le nom est déjà créé
                                continuer = true;
                            }
                        }
                    } else {
                        continuer = false;
                        ligneRsValide = false;

                    }
                } while (continuer);

                if(ligneRsValide){
                    nom = res.getString("NOM");
                    carte = res.getString("CARTE");

                    listeDeDescriptables.add(new Lieu(nom, carte));
                    //On cherche à savoir si le dernier element du resultset a déjà été ajouté
                    //(ce qui voudrait dire qu'on a déjà ajouté tous les autres)
                    //Dans ce cas, on sort de la boucle.

                    refaireUnTour = true;
                    res.last();    
                    String nomDuDernierElementRs = res.getString("NOM");
                    for (Descriptable descriptableCourant : listeDeDescriptables) {
                        if(nomDuDernierElementRs.equals(descriptableCourant.getLibelle())){
                            refaireUnTour = false;
                        }
                    }
                }

            } while (refaireUnTour);

        } catch (SQLException e) {
            throw new RuntimeException("Problème avec la requête SQL");
        }
        return listeDeDescriptables;
    }
    
    
    
    /*
     public List<Descriptable> requeteDeRechercheLieu(String chaineArechercher, boolean rechercheSpecifique) {
     Connection conn = dao.obtenirConnexion();
     List<Descriptable> listeDeDescriptables = new ArrayList<>();
     Lieu a;

     try (Statement st = conn.createStatement()) {
     if(!rechercheSpecifique){
     res = st.executeQuery("SELECT NOM, TEXTE, LIENS, IMAGE\n"
     + "FROM (((((LIEUX INNER JOIN DESCRIPTIF_COMPLEXE \n"
     + "ON LIEUX.ID_DESCRIPTIF = DESCRIPTIF_COMPLEXE.ID_DESCRIPTIF)\n"
     + "INNER JOIN HYPERTEXTE_DESCRIPTIF\n"
     + "ON DESCRIPTIF_COMPLEXE.ID_DESCRIPTIF = HYPERTEXTE_DESCRIPTIF.ID_DESCRIPTIF)\n"
     + "INNER JOIN LIENS_HYPERTEXTE\n"
     + "ON HYPERTEXTE_DESCRIPTIF.ID_LIENS = LIENS_HYPERTEXTE.ID_LIENS)\n"
     + "INNER JOIN IMAGES_DESCRIPTIF\n"
     + "ON IMAGES_DESCRIPTIF.ID_DESCRIPTIF = DESCRIPTIF_COMPLEXE.ID_DESCRIPTIF)\n"
     + "INNER JOIN IMAGES\n"
     + "ON IMAGES_DESCRIPTIF.ID_IMAGE = IMAGES.ID_IMAGE)\n"
     + "WHERE TEXTE LIKE \"%" + chaineArechercher + "%\" OR NOM LIKE \"%" + chaineArechercher + "%\" ");
     }else{
     res = st.executeQuery("SELECT NOM, TEXTE, LIENS, IMAGE\n"
     + "FROM (((((LIEUX INNER JOIN DESCRIPTIF_COMPLEXE \n"
     + "ON LIEUX.ID_DESCRIPTIF = DESCRIPTIF_COMPLEXE.ID_DESCRIPTIF)\n"
     + "INNER JOIN HYPERTEXTE_DESCRIPTIF\n"
     + "ON DESCRIPTIF_COMPLEXE.ID_DESCRIPTIF = HYPERTEXTE_DESCRIPTIF.ID_DESCRIPTIF)\n"
     + "INNER JOIN LIENS_HYPERTEXTE\n"
     + "ON HYPERTEXTE_DESCRIPTIF.ID_LIENS = LIENS_HYPERTEXTE.ID_LIENS)\n"
     + "INNER JOIN IMAGES_DESCRIPTIF\n"
     + "ON IMAGES_DESCRIPTIF.ID_DESCRIPTIF = DESCRIPTIF_COMPLEXE.ID_DESCRIPTIF)\n"
     + "INNER JOIN IMAGES\n"
     + "ON IMAGES_DESCRIPTIF.ID_IMAGE = IMAGES.ID_IMAGE)\n"
     + "WHERE TEXTE = " + chaineArechercher + " OR NOM = " + chaineArechercher + "");    
     }
     String nom = "";
     String texte = "";
     List<String> hypertexte;// = new ArrayList<>();
     List<String> images;// = new ArrayList<>();
     boolean trouve;
     boolean continuer = false;
     boolean refaireUnTour = false;
     int compteur;
     //Pour chaque Lieu différent du resultSet
     do {
     compteur = 0;
     while(res.next()){
     compteur++;
     }
                
     res.first();
     do {
     hypertexte = new ArrayList<>();
     images = new ArrayList<>();
     if(res.next()){

     nom = res.getString("NOM");
     texte = res.getString("TEXTE");
     trouve = false;
     for (Descriptable descriptableCourant : listeDeDescriptables) {
     if (descriptableCourant.getLibelle().equals(nom)) {
     //On indique que le lieu dont on a le nom est déjà créé
     trouve = true;
     }

     if (trouve) {
     continuer = true;
     } else {
     continuer = false;
     }
     }
     }
     else
     continuer=false;
     } while (continuer);
                
     res.first();
     compteur = 0;
     while(res.next()){
     compteur++;
     }
                
                
     //On remet le curseur sur le premier element du resultSet
     res.first();

                
     //  *On cherche à ajouter les liens hypertextes de chaque ligne du ResultSet dans la liste hypertexte
     //  *uniquement si ils n'y sont pas déjà présents
                 
     trouve = false;
     hypertexte.clear();
     //Tant qu'il reste des lignes à parcourir
     do {
     //Si il est possible d'avancer d'une ligne
     if(res.next())
     {
     //On annule l'avancée
     res.previous();


     //On tente d'ajouter seulment si le lieu correspond à celui dont on a le nom.
     if (res.getString("NOM").equals(nom)) {
     //Pour chacun des éléments de la liste hypertexte
     for (String hypertexteCourant : hypertexte) {
     //On check si le lien hypertexte de la ligne courante du resultSet est celui présent dans le string courant de la liste hypertexte.
     if (res.getString("LIENS").equals(hypertexteCourant)) {
     //Si le lien est déjà présent, on passe trouve à true.
     trouve = true;
     }
     }
     //Si le lien n'est pas encore présent dans la liste
     if (trouve == false) {
     hypertexte.add(res.getString("LIENS"));
     }
     }
     }
     } while (res.next());
            
                
     // Idem que pour hypertexte mais pour les images
                 
     res.first();
     trouve = false;
     images.clear();
     do {
     //Si il est possible d'avancer d'une ligne
     if(res.next())
     {
     //On annule l'avancée
     res.previous();

     //On tente d'ajouter seulment si le lieu correspond à celui dont on a le nom.
     if (res.getString("NOM").equals(nom)) {
     //Pour chacun des éléments de la liste images
     for (String imageCourante : images) {
     //On check si le lien image de la ligne courante du resultSet est celui présent dans le string courant de la liste images.
     if (res.getString("IMAGE").equals(imageCourante)) {
     //Si le lien est déjà présent, on passe trouve à true.
     trouve = true;
     }
     }
     //Si le lien n'est pas encore présent dans la liste
     if (trouve == false) {
     //On l'ajoute à la liste
     images.add(res.getString("IMAGE"));
     }
     }
     }
     //Tant qu'il y a des lignes au resultSet
     } while (res.next());

     //    a = new Lieu(nom, texte, hypertexte, images);
     listeDeDescriptables.add(new Lieu(nom, texte, hypertexte, images));

     for (Descriptable descriptableCourant : listeDeDescriptables) {
     if(res.next()){
     res.previous();

     if (descriptableCourant.getLibelle().equals(nom)) {
     refaireUnTour = true;
     }

     /*
     On cherche à savoir si le dernier element du resultset a déjà été ajouté
     (ce qui voudrait dire qu'on a déjà ajouté tous les autres)
     Dans ce cas, on sort de la boucle.
                        

     res.last();
     String nomDuDernierElementRs = res.getString("NOM");

     if(nomDuDernierElementRs.equals(nom))
     refaireUnTour=false;
     }
     }


     } while (refaireUnTour);

     } catch (SQLException ex) {
     Logger.getLogger(RqtDispenser.class.getName()).log(Level.SEVERE, null, ex);
     }

     return listeDeDescriptables;
     }
    
     */
    //-------------GESTION DE NEWS--------------

    public List<Descriptable> getNews() {
        String rq_sql = "";
        return null;
    }
//    public Parcours SelectParcours(String nom) {
//        Connection conn = dao.obtenirConnexion();
//        Parcours parcours = null;
//        List<String> POI = new ArrayList<>();
//        try (Statement st = conn.createStatement()) {
//            res = st.executeQuery("SELECT parcours_thematique.Libelle,poi.Libelle FROM Parcours_thematique\n"
//                    + "INNER JOIN poi_parcours \n"
//                    + "ON parcours_thematique.ID_Parcours=poi_parcours.ID_Parcours\n"
//                    + "INNER JOIN poi\n"
//                    + "ON poi_parcours.ID_POI=poi.ID_POI WHERE parcours_thematique.Libelle = '" + nom + "'");
//            while (res.next()) {
//                parcours = new Parcours();
//                parcours.getLibelle(res.getString("parcours_thematique.Libelle"));
//
//            }
//            
//             System.out.println(parcours);
//        } catch (SQLException ex) {
//            throw new RuntimeException("Execution de la requête SelectLieu impossible.");
//        }
//        return parcours;
//    }
}
//  throw new RuntimeException("Execution de la requête impossible.");
/*
 public List<List<String>> requeteDeRecherche(String chaineArechercher){
 List<List<String>> listeDeResultats = new ArrayList<List<String>>();
 try(Statement st = conn.createStatement()){
 res = st.executeQuery("SELECT NOM, TEXTE "
 + "FROM (LIEUX INNER JOIN DESCRIPTIF_COMPLEXE "
 + "ON LIEUX.ID_DESCRIPTIF = DESCRIPTIF_COMPLEXE.ID_DESCRIPTIF)"
 + "WHERE NOM LIKE \"%"+chaineArechercher+"%\" OR TEXTE LIKE \"%"+chaineArechercher+"%\" ");
            
 while(res.next()){
 List<String> nomTexte = new ArrayList<>();
 nomTexte.add(res.getString(1));
 nomTexte.add(res.getString(2));
                
 listeDeResultats.add(nomTexte);
 //    listeDeResultats.add(res.getString("NOM"), res.getString("TEXTE"));
 }
 } catch(SQLException e){
 throw new RuntimeException("Execution de la requête impossible.");
 }
 return listeDeResultats;
 */
